/**
 * 
 */
package com.lanswon.qzsmk.util;

import java.math.BigDecimal;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import org.junit.Assert;
import org.junit.Test;

import com.itextpdf.text.log.SysoCounter;

/**
 * @author sun
 *
 */
public class CommonUtil {

	/**
	 * 金额 格式化 例如：10.00
	 */
	public static String convertMoney_00(BigDecimal yuan) {
		return yuan.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString();
	}

	@Test
	public void test() {
		System.out.println(convertMoney_00(new BigDecimal(109)));
	}

	/**
	 * 金额 元 转分 长度10 前补0
	 */
	public static String convertMoney(BigDecimal yuan) {
		BigDecimal fen = yuan.multiply(new BigDecimal(100));
		String a = CitizenCardNoGeneratorUtil.generatorSeq(fen.stripTrailingZeros().toPlainString(), 10);
		return a;
	}

	@Test
	public void convertMoney() {
		System.out.println(convertMoney(new BigDecimal("10.00")));
	}

	/**
	 * 金额 分 转元 1111 --> 11.11
	 */
	public static BigDecimal convertMoney_1(String fen) {
		BigDecimal a = new BigDecimal(fen);
		BigDecimal b = a.divide(new BigDecimal(100), 2, BigDecimal.ROUND_HALF_UP);
		return b;
	}

	@Test
	public void convertMoney_1_test() {
		BigDecimal a = new BigDecimal(100).setScale(2, BigDecimal.ROUND_HALF_UP);
		System.out.println(a.toPlainString());
	}

	/**
	 * 字符转换acsii
	 * 
	 * @param ch
	 * @return
	 */
	public static byte charToByteAscii(char ch) {
		byte byteAscii = (byte) ch;

		return byteAscii;
	}

	public static void main(String[] args) throws ParseException {
		System.out.println(stringToAscii("120000000001"));
		System.out.println(AsciiStringToString("313230303030303030303031"));
		System.out.println(romNum());
		System.out.println(hexMoneyTOdouble("00049940"));
		System.out.println(hexMoneyTOdouble("00000010"));
		String aString = hexMoneyTOdouble("00000010");
		double a = Double.valueOf(aString);
		System.out.println((int) (a * 100));

		System.out.println(Integer.toHexString(29));

	}

	/**
	 * StringToAscII
	 * 
	 * @param value
	 * @return
	 */
	public static String stringToAscii(String value) {
		StringBuffer sbu = new StringBuffer();
		char[] chars = value.toCharArray();
		for (int i = 0; i < chars.length; i++) {
			if (i != chars.length - 1) {
				sbu.append(Integer.toHexString((int) chars[i]));
			} else {
				sbu.append(Integer.toHexString((int) chars[i]));
			}
		}
		return sbu.toString();

	}

	/**
	 * HEX字符串前补0，主要用于长度位数不足
	 * 
	 * @param str
	 * @param maxLength
	 * @return
	 */
	static public String patchHexString(String str, int maxLength) {
		String temp = "";
		for (int i = 0; i < maxLength - str.length(); i++) {
			temp = "0" + temp;
		}
		str = (temp + str).substring(0, maxLength);
		return str;
	}

	/**
	 * 获取list中的重复数据
	 * 
	 * @param list
	 * @return
	 */
	public static List getDuplicate(List list) {
		List l = new ArrayList<>();
		for (int i = 0; i < list.size() - 1; i++) {
			for (int j = list.size() - 1; j > i; j--) {
				if (list.get(j).equals(list.get(i))) {
					l.add(l);
					System.out.println("dup:" + list.get(j));
				}
			}
		}
		return l;
	}

	public static String hexToDec(String hex) {
		long dec = Long.parseLong(hex, 16);
		return String.valueOf(dec);
	}

	public static String AsciiStringToString(String content) {
		String result = "";
		int length = content.length() / 2;
		for (int i = 0; i < length; i++) {
			String c = content.substring(i * 2, i * 2 + 2);
			int a = hexStringToAlgorism(c);
			char b = (char) a;
			String d = String.valueOf(b);
			result += d;
		}
		return result;
	}

	public static int hexStringToAlgorism(String hex) {
		hex = hex.toUpperCase();
		int max = hex.length();
		int result = 0;
		for (int i = max; i > 0; i--) {
			char c = hex.charAt(i - 1);
			int algorism = 0;
			if (c >= '0' && c <= '9') {
				algorism = c - '0';
			} else {
				algorism = c - 55;
			}
			result += Math.pow(16, max - i) * algorism;
		}
		return result;
	}

	/**
	 * 将16进制money转为double字符串
	 * 
	 * @param hexMOney
	 * @return
	 */
	public static String hexMoneyTOdouble(String hexMOney) {
		String balance = null;
		String moneyStr;
		int hexlen;
		hexlen = hexMOney.length();
		int offset; // '补0数
		String tmp = null;
		int i;
		offset = 8 - hexlen;
		if (offset > 0) {
			for (i = 1; i < offset; i++) {
				tmp = tmp + "0";
			}
		}
		moneyStr = (Integer.valueOf(hexMOney, 16)).toString();
		int moneylen = moneyStr.length();
		// System.out.println(moneyStr);
		// 负数
		if (Double.valueOf(moneyStr) < 0) {
			if (moneylen == 2) {
				balance = "-0.0" + moneyStr.substring(1, moneylen);
			}
			if (moneylen == 3) {
				balance = "-0." + moneyStr.substring(1, moneylen);
			}
			if (moneylen > 3) {
				String yuan1 = null;
				yuan1 = moneyStr.substring(0, moneylen - 2);
				// System.out.println(yuan1);
				balance = yuan1 + "." + moneyStr.substring(moneylen - 2);
			}
			return balance;
		}
		if (moneylen == 1) {
			balance = "0.0" + moneyStr;
		}
		if (moneylen == 2) {
			balance = "0." + moneyStr;
		}
		if (moneylen > 2) {
			String yuan1 = null;
			yuan1 = moneyStr.substring(0, moneylen - 2);
			// System.out.println(yuan1);
			balance = yuan1 + "." + moneyStr.substring(moneylen - 2, moneylen);
		}
		return balance;

	}

	/**
	 * 计算将来固定时间
	 * 
	 * @param date
	 * @return
	 * @throws ParseException
	 */
	public static Date willDate(Date date, int months) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.add(Calendar.MONTH, months);
		Date d = c.getTime();
		return d;
	}

	/**
	 * 字符串转化成为16进制字符串
	 * 
	 * @param s
	 * @return
	 */
	public static String strTo16(String s) {
		String str = "";
		for (int i = 0; i < s.length(); i++) {
			int ch = (int) s.charAt(i);
			String s4 = Integer.toHexString(ch);
			str = str + s4;
		}
		return str;
	}

	/**
	 * 生成随机数
	 * 
	 * @return
	 */
	public static String romNum() {
		Double double1 = Math.random();
		int a = (int) (double1 * 1000000);
		return String.valueOf(a);
	}

	public static boolean isIDNumber(String IDNumber) {
		if (IDNumber == null || "".equals(IDNumber)) {
			return false;
		}
		// 定义判别用户身份证号的正则表达式（15位或者18位，最后一位可以为字母）
		String regularExpression = "(^[1-9]\\d{5}(18|19|20)\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$)|"
				+ "(^[1-9]\\d{5}\\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\\d{3}$)";
		// 假设18位身份证号码:41000119910101123X 410001 19910101 123X
		// ^开头
		// [1-9] 第一位1-9中的一个 4
		// \\d{5} 五位数字 10001（前六位省市县地区）
		// (18|19|20) 19（现阶段可能取值范围18xx-20xx年）
		// \\d{2} 91（年份）
		// ((0[1-9])|(10|11|12)) 01（月份）
		// (([0-2][1-9])|10|20|30|31)01（日期）
		// \\d{3} 三位数字 123（第十七位奇数代表男，偶数代表女）
		// [0-9Xx] 0123456789Xx其中的一个 X（第十八位为校验值）
		// $结尾

		// 假设15位身份证号码:410001910101123 410001 910101 123
		// ^开头
		// [1-9] 第一位1-9中的一个 4
		// \\d{5} 五位数字 10001（前六位省市县地区）
		// \\d{2} 91（年份）
		// ((0[1-9])|(10|11|12)) 01（月份）
		// (([0-2][1-9])|10|20|30|31)01（日期）
		// \\d{3} 三位数字 123（第十五位奇数代表男，偶数代表女），15位身份证不含X
		// $结尾

		boolean matches = IDNumber.matches(regularExpression);

		// 判断第18位校验值
		if (matches) {

			if (IDNumber.length() == 18) {
				try {
					char[] charArray = IDNumber.toCharArray();
					// 前十七位加权因子
					int[] idCardWi = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };
					// 这是除以11后，可能产生的11位余数对应的验证码
					String[] idCardY = { "1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2" };
					int sum = 0;
					for (int i = 0; i < idCardWi.length; i++) {
						int current = Integer.parseInt(String.valueOf(charArray[i]));
						int count = current * idCardWi[i];
						sum += count;
					}
					char idCardLast = charArray[17];
					int idCardMod = sum % 11;
					if (idCardY[idCardMod].toUpperCase().equals(String.valueOf(idCardLast).toUpperCase())) {
						return true;
					} else {
						System.out.println("身份证最后一位:" + String.valueOf(idCardLast).toUpperCase() + "错误,正确的应该是:"
								+ idCardY[idCardMod].toUpperCase());
						return false;
					}

				} catch (Exception e) {
					e.printStackTrace();
					System.out.println("异常:" + IDNumber);
					return false;
				}
			}

		}
		return matches;
	}

	@Test
	public void isIDNumberTest() {
		boolean b = isIDNumber("321731198108155210");
		Assert.assertTrue(b);
	}

	/**
	 * date2比date1多的天数
	 * 
	 * @param date1
	 * @param date2
	 * @return
	 */
	public static int differentDays(Date date1, Date date2) {
		Calendar cal1 = Calendar.getInstance();
		cal1.setTime(date1);

		Calendar cal2 = Calendar.getInstance();
		cal2.setTime(date2);
		int day1 = cal1.get(Calendar.DAY_OF_YEAR);
		int day2 = cal2.get(Calendar.DAY_OF_YEAR);

		int year1 = cal1.get(Calendar.YEAR);
		int year2 = cal2.get(Calendar.YEAR);
		if (year1 != year2) // 同一年
		{
			int timeDistance = 0;
			for (int i = year1; i < year2; i++) {
				if (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) // 闰年
				{
					timeDistance += 366;
				} else // 不是闰年
				{
					timeDistance += 365;
				}
			}

			return timeDistance + (day2 - day1);
		} else // 不同年
		{
			System.out.println("判断day2 - day1 : " + (day2 - day1));
			return day2 - day1;
		}
	}

	//查看编码格式
	public static String getEncoding(String str) {
		String encode = "GB2312";
		try {
			if (str.equals(new String(str.getBytes(encode), encode))) { // 判断是不是GB2312
				String s = encode;
				return s; // 是的话，返回“GB2312“，以下代码同理
			}
		} catch (Exception exception) {
		}
		encode = "ISO-8859-1";
		try {
			if (str.equals(new String(str.getBytes(encode), encode))) { // 判断是不是ISO-8859-1
				String s1 = encode;
				return s1;
			}
		} catch (Exception exception1) {
		}
		encode = "UTF-8";
		try {
			if (str.equals(new String(str.getBytes(encode), encode))) { // 判断是不是UTF-8
				String s2 = encode;
				return s2;
			}
		} catch (Exception exception2) {
		}
		encode = "GBK";
		try {
			if (str.equals(new String(str.getBytes(encode), encode))) { // 判断是不是GBK
				String s3 = encode;
				return s3;
			}
		} catch (Exception exception3) {
		}
		return ""; // 如果都不是，说明输入的内容不属于常见的编码格式。
	}
}
